const Controller = require('egg').Controller;

class CircleController extends Controller {
    // 创建圈子（仅管理员）
    async create() {
        const { ctx, service } = this;

        try {
            // 验证管理员权限
            const token = ctx.request.header.admintoken;
            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);

            if (decode.type !== 'admin') {
                throw new Error('无权限创建圈子');
            }

            // 参数验证
            const rules = {
                name: { type: 'string', required: true },
                type: { type: 'string', required: true },
                description: { type: 'string', required: true }
            };
            ctx.validate(rules);

            const circleData = ctx.request.body;
            const result = await service.circle.create(circleData);

            ctx.body = {
                code: 0,
                data: result,
                msg: '创建成功'
            };
        } catch (error) {
            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '创建圈子失败'
            };
        }
    }

    // 获取圈子列表
    async list() {
        const { ctx, service } = this;

        try {
            const query = ctx.query;
            const result = await service.circle.getCircles(query);

            ctx.body = {
                code: 0,
                data: result,
                msg: '获取成功'
            };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '获取圈子列表失败'
            };
        }
    }

    // 获取圈子详情
    async detail() {
        const { ctx, service } = this;

        try {
            const { id } = ctx.params;

            // 验证ID参数
            const rules = {
                id: { type: 'id', required: true }
            };
            ctx.validate(rules, ctx.params);

            const circle = await service.circle.getCircleById(id);

            ctx.body = {
                code: 0,
                data: circle,
                msg: '获取成功'
            };
        } catch (error) {
            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '获取圈子详情失败'
            };
        }
    }

    // 更新圈子信息（仅管理员）
    async update() {
        const { ctx, service } = this;

        try {
            const { id } = ctx.params;
            const updateData = ctx.request.body;

            // 验证管理员权限
            const token = ctx.request.header.admintoken;
            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);

            if (decode.type !== 'admin') {
                throw new Error('无权限更新圈子');
            }

            // 验证路径参数
            const paramRules = {
                id: { type: 'id', required: true }
            };
            ctx.validate(paramRules, ctx.params);

            // 验证body参数
            const bodyRules = {
                name: { type: 'string', required: false },
                type: { type: 'string', required: false },
                description: { type: 'string', required: false }
            };
            ctx.validate(bodyRules);

            const result = await service.circle.updateCircle(id, updateData);

            ctx.body = {
                code: 0,
                data: result,
                msg: '更新成功'
            };
        } catch (error) {
            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '更新圈子失败'
            };
        }
    }

    // 删除圈子（仅管理员）
    async delete() {
        const { ctx, service } = this;

        try {
            const { id } = ctx.params;

            // 验证管理员权限
            const token = ctx.request.header.admintoken;
            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);

            if (decode.type !== 'admin') {
                throw new Error('无权限删除圈子');
            }

            // 验证ID参数
            const rules = {
                id: { type: 'id', required: true }
            };
            ctx.validate(rules, ctx.params);

            await service.circle.deleteCircle(id);

            ctx.body = {
                code: 0,
                data: null,
                msg: '删除成功'
            };
        } catch (error) {
            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '删除圈子失败'
            };
        }
    }

    // 获取热门圈子
    async hot() {
        const { ctx, service } = this;

        try {
            const { limit = 10 } = ctx.query;
            const circles = await service.circle.getHotCircles(limit);

            ctx.body = {
                code: 0,
                data: circles,
                msg: '获取成功'
            };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '获取热门圈子失败'
            };
        }
    }

    // 搜索圈子
    async search() {
        const { ctx, service } = this;

        try {
            const { keyword } = ctx.query;

            if (!keyword || keyword.trim() === '') {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: '搜索关键词不能为空'
                };
                return;
            }

            const result = await service.circle.searchCircles(keyword.trim(), ctx.query);

            ctx.body = {
                code: 0,
                data: result,
                msg: '搜索成功'
            };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '搜索圈子失败'
            };
        }
    }

    // 获取圈子统计信息（仅管理员）
    async stats() {
        const { ctx, service } = this;

        try {
            // 验证管理员权限
            const token = ctx.request.header.admintoken;
            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);

            if (decode.type !== 'admin') {
                throw new Error('无权限查看统计信息');
            }

            const result = await service.circle.getCircleStats();

            ctx.body = {
                code: 0,
                data: result,
                msg: '获取成功'
            };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '获取统计信息失败'
            };
        }
    }

    // 用户加入圈子
    async join() {
        const { ctx, service } = this;

        try {
            const { circle_id } = ctx.request.body;
            // 参数验证
            const rules = {
                circle_id: { type: 'int', required: true }
            };
            ctx.validate(rules);

            // 从token中获取用户ID
            const token = ctx.request.header.token;
            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);
            if (decode.type !== 'user') {
                throw new Error('管理员不能加入圈子');
            }

            const result = await service.circle.joinCircle(decode.user_id, circle_id);

            ctx.body = {
                code: 0,
                data: result,
                msg: '加入圈子成功'
            };
        } catch (error) {
            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '加入圈子失败'
            };
        }
    }

    // 用户退出圈子
    async leave() {
        const { ctx, service } = this;

        try {
            const { circle_id } = ctx.request.body;

            // 参数验证
            const rules = {
                circle_id: { type: 'int', required: true }
            };
            ctx.validate(rules);

            // 从token中获取用户ID
            const token = ctx.request.header.token;
            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);
            if (decode.type !== 'user') {
                throw new Error('管理员不能退出圈子');
            }

            await service.circle.leaveCircle(decode.user_id, circle_id);

            ctx.body = {
                code: 0,
                data: null,
                msg: '退出圈子成功'
            };
        } catch (error) {
            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '退出圈子失败'
            };
        }
    }

    // 获取用户加入的圈子列表
    async userCircles() {
        const { ctx, service } = this;

        try {
            // 从token中获取用户ID
            const token = ctx.request.header.token;
            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);

            const query = ctx.query;
            const result = await service.circle.getUserJoinedCircles(decode.user_id, query);

            ctx.body = {
                code: 0,
                data: result,
                msg: '获取成功'
            };
        } catch (error) {
            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '获取用户圈子列表失败'
            };
        }
    }

    // 获取圈子的成员列表
    async members() {
        const { ctx, service } = this;

        try {
            const { circle_id } = ctx.query;

            // 参数验证
            const rules = {
                circle_id: { type: 'id', required: true }
            };
            ctx.validate(rules, ctx.query);

            const query = ctx.query;
            const result = await service.circle.getCircleMembers(circle_id, query);

            ctx.body = {
                code: 0,
                data: result,
                msg: '获取成功'
            };
        } catch (error) {
            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '获取成员列表失败'
            };
        }
    }

    // 批量获取用户与圈子的关系状态
    async batchStatus() {
        const { ctx, service } = this;

        try {
            const { circle_ids } = ctx.request.body;

            // 参数验证
            const rules = {
                circle_ids: { type: 'array', required: true }
            };
            ctx.validate(rules);

            // 从token中获取用户ID
            const token = ctx.request.header.token;
            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);

            const result = await service.circle.getUserCircleStatus(decode.user_id, circle_ids);

            ctx.body = {
                code: 0,
                data: result,
                msg: '获取成功'
            };
        } catch (error) {
            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '获取状态失败'
            };
        }
    }

    //管理员移除圈子的成员
    async removeMember() {
        const { ctx, service } = this;

        try {
            const { circle_id, user_id } = ctx.request.body;

            // 参数验证
            const rules = {
                circle_id: { type: 'int', required: true },
                user_id: { type: 'int', required: true }
            };
            ctx.validate(rules);

            // 从token中获取管理员ID
            const token = ctx.request.header.admintoken;
            const decode = ctx.app.jwt.verify(token, ctx.app.config.jwt.secret);

            if (decode.type !== 'admin') {
                throw new Error('无权限移除圈子成员');
            }

            const result = await service.circle.removeMember(circle_id, user_id);

            ctx.body = {
                code: 0,
                data: result,
                msg: '移除成功'
            };
        } catch (error) {
            if (error.errors) {
                ctx.body = {
                    code: 1,
                    data: null,
                    msg: `参数错误: ${error.errors[0].field} ${error.errors[0].message}`
                };
                return;
            }

            ctx.body = {
                code: 1,
                data: null,
                msg: error.message || '移除成员失败'
            };
        }
    }

}

module.exports = CircleController;